import 'dart:convert';
import 'dart:io';

import 'package:flutter_test/flutter_test.dart';
import 'package:integration_test/integration_test.dart';
import 'package:posthog_flutter/posthog_flutter.dart';

const host = 'http://127.0.0.1:8793';
const token = 'phc_local_e2e_test';

Future<void> control(String query) async {
  final c = HttpClient();
  final r = await (await c.getUrl(Uri.parse('$host/__set?$query'))).close();
  await r.drain<void>();
  c.close();
}

PostHogConfig cfg(List<String> order) => PostHogConfig(token)
  ..host = host
  ..flushAt = 1
  ..debug = true
  ..onFeatureFlags = (l) => order.add('config');

String? val(PostHogFeatureFlagsLoaded l) => l.variants['e2e-flag'] as String?;

Future<bool> until(bool Function() cond, [int secs = 20]) async {
  final end = DateTime.now().add(Duration(seconds: secs));
  while (DateTime.now().isBefore(end)) {
    if (cond()) return true;
    await Future<void>.delayed(const Duration(milliseconds: 100));
  }
  return cond();
}

Future<void> settle([int ms = 2500]) =>
    Future<void>.delayed(Duration(milliseconds: ms));

void main() {
  IntegrationTestWidgetsFlutterBinding.ensureInitialized();

  testWidgets('onFeatureFlags listener e2e', (tester) async {
    final failures = <String>[];
    void check(String name, bool ok, Object? detail) {
      // ignore: avoid_print
      print('E2E ${ok ? "PASS" : "FAIL"} $name :: $detail');
      if (!ok) failures.add(name);
    }

    final ph = Posthog();
    final order = <String>[];
    await control('version=1&fail=0');

    final a = <PostHogFeatureFlagsLoaded>[];
    final subA = ph.onFeatureFlags((l) {
      a.add(l);
      order.add('listener');
    });
    await ph.setup(cfg(order));
    check('1 listener added before setup gets first load',
        await until(() => a.any((l) => val(l) == 'v1-anon')), a);
    await settle(1000);
    final i = order.indexOf('listener');
    check('2 listener runs before config callback',
        i >= 0 && order.indexOf('config') > i, order);

    final b = <PostHogFeatureFlagsLoaded>[];
    final subB = ph.onFeatureFlags(b.add);
    await settle(1000);
    check('3 late listener gets exactly one replay',
        b.length == 1 && val(b.single) == 'v1-anon', b);

    await control('version=2');
    final reloadA = a.length;
    await ph.reloadFeatureFlags();
    check(
        '4 reloadFeatureFlags reaches all listeners',
        await until(() =>
            a.skip(reloadA).any((l) => val(l) == 'v2-anon') &&
            b.any((l) => val(l) == 'v2-anon')),
        'a=$a b=$b');

    final thrower = ph.onFeatureFlags((_) => throw StateError('boom'));
    final after = <PostHogFeatureFlagsLoaded>[];
    final subAfter = ph.onFeatureFlags(after.add);
    await settle(500);
    after.clear();
    await control('version=3');
    await ph.reloadFeatureFlags();
    check('5 throwing listener does not stop later ones',
        await until(() => after.any((l) => val(l) == 'v3-anon')), after);
    thrower.unsubscribe();
    subAfter.unsubscribe();

    subB.unsubscribe();
    final bCount = b.length;
    await control('version=4');
    await ph.reloadFeatureFlags();
    final got4 = await until(() => a.any((l) => val(l) == 'v4-anon'));
    await settle(1000);
    check('6 unsubscribe stops delivery, others continue',
        got4 && b.length == bCount, 'a4=$got4 b=${b.length}/$bCount');

    await ph.identify(userId: 'user-1');
    check('7 identify delivers the new user flags',
        await until(() => a.any((l) => val(l) == 'v4-user-1')), a.last);

    await ph.reset();
    final c = <PostHogFeatureFlagsLoaded>[];
    final subC = ph.onFeatureFlags(c.add);
    await settle(3000);
    check('8 listener added after reset never sees previous user',
        !c.any((l) => (val(l) ?? '').contains('user-1')), c);
    subC.unsubscribe();

    await control('fail=1');
    final beforeFail = a.length;
    await ph.reloadFeatureFlags();
    final gotFail =
        await until(() => a.skip(beforeFail).any((l) => l.errorsLoading));
    check('9 failed load reports errorsLoading', gotFail,
        a.skip(beforeFail).toList());
    await control('fail=0');

    await ph.close();
    final d = <PostHogFeatureFlagsLoaded>[];
    final subD = ph.onFeatureFlags(d.add);
    await settle(1500);
    check('10 no replay after close', d.isEmpty, d);
    await control('version=5');
    final beforeSetup = a.length;
    await ph.setup(cfg(order));
    check(
        '11 listeners survive close and setup',
        await until(() =>
            a.skip(beforeSetup).any((l) => val(l) == 'v5-anon') &&
            d.any((l) => val(l) == 'v5-anon')),
        'a=${a.skip(beforeSetup).toList()} d=$d');

    subA.unsubscribe();
    subD.unsubscribe();
    // ignore: avoid_print
    print('E2E DONE failures=${jsonEncode(failures)}');
    expect(failures, isEmpty);
  }, timeout: const Timeout(Duration(minutes: 5)));
}